home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus Leser 15 / Amiga Plus Leser CD 15.iso / Tools / Development / PluginSRC_EvenMore / Troff2Text2.e < prev    next >
Encoding:
Text File  |  2002-03-13  |  10.1 KB  |  403 lines
  1. /*
  2.    Troff2Text
  3.    EvenMore FileIO plugin
  4.    Author: Chris Perver
  5.    Copyright (c) 2001
  6. */
  7.  
  8.  
  9. OPT REG=5
  10.  
  11. LIBRARY 'troff2text.plugin',1,1,'Troff2Text 1.04' IS em_main, em_end, em_info, em_pluginid, em_begin, em_format
  12.  
  13. MODULE 'tools/ctype', '*epo'
  14.  
  15. DEF mem2:PTR TO CHAR, count2 =0, ww= TRUE, wordwrap = 80
  16.  
  17.  
  18. PROC em_isdatatype(bf, bl)
  19.   DEF pos = 0, rs = FALSE, working = TRUE
  20.  
  21.   WHILE working
  22.     IF Long(bf + pos) = ".TH "
  23.       working := FALSE
  24.       rs :=  TRUE
  25.     ENDIF
  26.  
  27.     WHILE bf[pos] <> "\n" DO INC pos
  28.     INC pos
  29.  
  30.     IF pos >= bl THEN working := FALSE
  31.   ENDWHILE
  32. ENDPROC rs
  33.  
  34. PROC em_parsedata(epo:PTR TO em_pluginobj)
  35.   DEF memadr:PTR TO CHAR, lenadr, len2
  36.   DEF count = 0
  37.   DEF notdone = TRUE
  38.  
  39.   DEF man[256]:STRING, cchar = 0 ->, notdonewrapping = FALSE
  40.   DEF lineend
  41.  
  42.   memadr := epo.buffer
  43.   lenadr := epo.length
  44.  
  45.   mem2 := epo.nbuffer
  46.   len2 := epo.nlength
  47.  
  48.   mem2[len2] := "\n"
  49.  
  50.   WHILE notdone AND (count < lenadr)
  51.     lineend := count
  52.     WHILE memadr[lineend] <> "\n" DO INC lineend
  53.     INC lineend
  54.  
  55.  
  56.     SELECT 256 OF memadr[count]
  57.       CASE "."
  58.         IF (count = 0) OR (memadr[count-1] = "\n")
  59.  
  60.           StrCopy(man, memadr + count, 10)
  61.           SELECT 256 OF memadr[count+1]
  62.             CASE "b", "B"
  63.  
  64.               -> LINEBREAK
  65.               IF InStr(man, '.br') = 0
  66.                 mem2[count2++] := "\n"
  67.                 mem2[count2++] := "\n"
  68.                 cchar := 0
  69.                 count := count + 4
  70.  
  71.                 count, count2, cchar := parseescapecodes(memadr, count, lineend, mem2, count2, cchar)
  72.  
  73.                 mem2[count2++] := "\n"
  74.                 mem2[count2++] := "\n"
  75.                 cchar := 0
  76.  
  77.               -> BOLD
  78.               ELSEIF InStr(man, '.B ') = 0
  79.                 mem2[count2++] := "\e"
  80.                 mem2[count2++] := "["
  81.                 mem2[count2++] := "1"
  82.                 mem2[count2++] := "m"
  83.                 count := count + 3
  84.  
  85.                 count, count2, cchar := parseescapecodes(memadr, count, lineend, mem2, count2, cchar)
  86.  
  87.                 mem2[count2++] := "\e"
  88.                 mem2[count2++] := "["
  89.                 mem2[count2++] := "0"
  90.                 mem2[count2++] := "m"
  91.  
  92.               -> BOLDITALIC
  93.               ELSEIF InStr(man, '.BI ') = 0
  94.                 mem2[count2++] := "\e"
  95.                 mem2[count2++] := "["
  96.                 mem2[count2++] := "1"
  97.                 mem2[count2++] := "m"
  98.                 count := count + 4
  99.  
  100.                 count, count2, cchar := parseescapecodes(memadr, count, lineend, mem2, count2, cchar)
  101.  
  102.                 mem2[count2++] := "\e"
  103.                 mem2[count2++] := "["
  104.                 mem2[count2++] := "0"
  105.                 mem2[count2++] := "m"
  106.  
  107.               -> BOLDROMAN
  108.               ELSEIF InStr(man, '.BR ') = 0
  109.                 mem2[count2++] := "\e"
  110.                 mem2[count2++] := "["
  111.                 mem2[count2++] := "1"
  112.                 mem2[count2++] := "m"
  113.                 count := count + 4
  114.  
  115.                 count, count2, cchar := parseescapecodes(memadr, count, lineend, mem2, count2, cchar)
  116.  
  117.                 mem2[count2++] := "\e"
  118.                 mem2[count2++] := "["
  119.                 mem2[count2++] := "0"
  120.                 mem2[count2++] := "m"
  121.               ELSE
  122.                 count := lineend
  123.               ENDIF
  124.             CASE "i", "I"
  125.  
  126.               -> ITALIC
  127.               IF InStr(man, '.I ') = 0
  128.                 mem2[count2++] := "\e"
  129.                 mem2[count2++] := "["
  130.                 mem2[count2++] := "3"
  131.                 mem2[count2++] := "m"
  132.                 count := count + 3
  133.  
  134.                 count, count2, cchar := parseescapecodes(memadr, count, lineend, mem2, count2, cchar)
  135.  
  136.                 mem2[count2++] := "\e"
  137.                 mem2[count2++] := "["
  138.                 mem2[count2++] := "0"
  139.                 mem2[count2++] := "m"
  140.  
  141.               -> ITALIC ROMAN
  142.               ELSEIF InStr(man, '.IR ') = 0
  143.                 mem2[count2++] := "\e"
  144.                 mem2[count2++] := "["
  145.                 mem2[count2++] := "3"
  146.                 mem2[count2++] := "m"
  147.                 count := count + 4
  148.  
  149.                 count, count2, cchar := parseescapecodes(memadr, count, lineend, mem2, count2, cchar)
  150.  
  151.                 mem2[count2++] := "\e"
  152.                 mem2[count2++] := "["
  153.                 mem2[count2++] := "0"
  154.                 mem2[count2++] := "m"
  155.  
  156.               -> ITALIC BOLD
  157.               ELSEIF InStr(man, '.IB ') = 0
  158.                 mem2[count2++] := "\e"
  159.                 mem2[count2++] := "["
  160.                 mem2[count2++] := "3"
  161.                 mem2[count2++] := "m"
  162.                 count := count + 4
  163.  
  164.                 count, count2, cchar := parseescapecodes(memadr, count, lineend, mem2, count2, cchar)
  165.  
  166.                 mem2[count2++] := "\e"
  167.                 mem2[count2++] := "["
  168.                 mem2[count2++] := "0"
  169.                 mem2[count2++] := "m"
  170.  
  171.               -> PARAGRAPH
  172.               ELSEIF InStr(man, '.IP') = 0
  173.                 mem2[count2++] := "\n"
  174.                 mem2[count2++] := "\n"
  175.                 mem2[count2++] := "\t"
  176.                 cchar := 1
  177.                 count := count + 4
  178.               ELSE
  179.                 count := lineend
  180.               ENDIF
  181.  
  182.             CASE "l", "L"
  183.               IF InStr(man, '.LP') = 0
  184.                 mem2[count2++] := "\n"
  185.                 mem2[count2++] := "\n"
  186.                 count := count + 4
  187.                 cchar := 0
  188.               ELSE
  189.                 count := lineend
  190.               ENDIF
  191.  
  192.             CASE "S"
  193.  
  194.               -> SECTION HEADING INDENTED BOLD
  195.               IF InStr(man, '.SH') = 0
  196.                 mem2[count2++] := "\n"
  197.                 mem2[count2++] := "\n"
  198.                 mem2[count2++] := "\t"
  199.                 cchar := 1
  200.  
  201.                 mem2[count2++] := "\e"
  202.                 mem2[count2++] := "["
  203.                 mem2[count2++] := "1"
  204.                 mem2[count2++] := "m"
  205.  
  206.                 count := count + 4
  207.  
  208.                 count, count2, cchar := parseescapecodes(memadr, count, lineend, mem2, count2, cchar)
  209.  
  210.                 mem2[count2++] := "\e"
  211.                 mem2[count2++] := "["
  212.                 mem2[count2++] := "0"
  213.                 mem2[count2++] := "m"
  214.  
  215.                 mem2[count2++] := "\n"
  216.                 mem2[count2++] := "\n"
  217.                 cchar := 0
  218.  
  219.               -> SECTION HEADING BOLD
  220.               ELSEIF InStr(man, '.SS') = 0
  221.                 mem2[count2++] := "\n"
  222.                 mem2[count2++] := "\n"
  223.                 cchar := 0
  224.  
  225.                 mem2[count2++] := "\e"
  226.                 mem2[count2++] := "["
  227.                 mem2[count2++] := "1"
  228.                 mem2[count2++] := "m"
  229.  
  230.                 count := count + 4
  231.  
  232.                 count, count2, cchar := parseescapecodes(memadr, count, lineend, mem2, count2, cchar)
  233.  
  234.                 mem2[count2++] := "\e"
  235.                 mem2[count2++] := "["
  236.                 mem2[count2++] := "0"
  237.                 mem2[count2++] := "m"
  238.  
  239.                 mem2[count2++] := "\n"
  240.                 mem2[count2++] := "\n"
  241.                 cchar := 0
  242.  
  243.               ELSE
  244.                 count := lineend
  245.               ENDIF
  246.             CASE "T"
  247.  
  248.               -> HEADER
  249.               IF InStr(man, '.TH') = 0
  250.                 mem2[count2++] := "\n"
  251.                 mem2[count2++] := "\n"
  252.                 cchar := 0
  253.                 count := count + 4
  254.  
  255.                 count, count2, cchar := parseescapecodes(memadr, count, lineend, mem2, count2, cchar)
  256.  
  257.                 mem2[count2++] := "\n"
  258.                 mem2[count2++] := "\n"
  259.                 cchar := 0
  260.               ELSEIF InStr(man, '.TP') = 0
  261.                 mem2[count2++] := "\n"
  262.                 mem2[count2++] := "\n"
  263.                 mem2[count2++] := "\t"
  264.                 cchar := 1
  265.                 count := count + 4
  266.               ELSE
  267.                 count := lineend
  268.               ENDIF
  269.             DEFAULT
  270.               count := lineend
  271.           ENDSELECT
  272.         ELSE
  273.           mem2[count2++] := memadr[count++]
  274.           INC cchar
  275.         ENDIF
  276.  
  277.     DEFAULT
  278.       count, count2, cchar := parseescapecodes(memadr, count, lineend, mem2, count2, cchar)
  279.  
  280.     ENDSELECT
  281.   ENDWHILE
  282. ->  count2 := count2 - 120
  283. ENDPROC mem2, count2
  284. -><
  285.  
  286. PROC parseescapecodes(m, c, l, m2, c2, cc)
  287.   DEF notdonewrapping = FALSE, oldpos, newcc = 0
  288.  
  289.   WHILE (c < l)
  290.     SELECT 256 OF m[c]
  291.       -> \
  292.       CASE $5C
  293.         SELECT 256 OF m[c+1]
  294.           -> INTERPOLATE TEXT
  295.           CASE "w"
  296.             c := l
  297.  
  298.           -> $ MACRO ARGS
  299.           CASE "$"
  300.             c := l
  301.  
  302.           -> \
  303.           CASE $5C
  304.             INC c
  305.  
  306.           -> PRINT ESC CHAR
  307.           CASE "e"
  308.             m2[c2++] := $5C
  309.             INC cc
  310.             c := c + 2
  311.  
  312.           -> ZERO WIDTH SPACE
  313.           CASE "&"
  314.             c := c + 2
  315.  
  316.           -> COMMENT
  317.           CASE $22
  318.             c := l
  319.  
  320.           -> DASH
  321.           CASE "-"
  322.             INC c
  323.  
  324.           -> TAB
  325.           CASE "t"
  326.             m2[c2++] := "\t"
  327.             INC cc
  328.             c := l
  329.         DEFAULT
  330.           m2[c2++] := m[c++]
  331.           INC cc
  332.         ENDSELECT
  333.  
  334.       -> EOL
  335.       CASE "\b", "\n"
  336.         -> MAKE SURE WE HAVE A SPACE BEFORE THE NEXT SENTENCE
  337.         IF m[c] = "\n"
  338.           m2[c2++] := " "
  339.           INC cc
  340.         ENDIF
  341.         INC c
  342.  
  343.      DEFAULT
  344.  
  345.        m2[c2++] := m[c++]
  346.        INC cc
  347.  
  348.  
  349.        IF ww = TRUE
  350.          IF (cc >= wordwrap) AND (c < l)
  351.            oldpos := c2
  352.  
  353.            notdonewrapping := TRUE
  354.            WHILE notdonewrapping
  355.              m2[oldpos+1] := m2[oldpos]
  356.  
  357.              IF isspace(m2[oldpos-1]) = FALSE
  358.                DEC oldpos
  359.                DEC newcc
  360.              ELSE
  361.                m2[oldpos] := "\n"
  362.  
  363.                c2++
  364.                cc := (c2 - oldpos)
  365.                notdonewrapping := FALSE
  366.             ->   WriteF('1')
  367.              ENDIF
  368.            ENDWHILE
  369.          ENDIF
  370.        ENDIF
  371.  
  372.      ENDSELECT
  373.   ENDWHILE
  374. ENDPROC c, c2, cc
  375.  
  376. -> *** STANDARD PROCS FOR PLUGINS
  377.  
  378.  
  379. PROC em_begin(epo:PTR TO em_pluginobj)
  380.   IF em_isdatatype(epo.buffer, epo.length)
  381.     RETURN "MEM", (epo.length * 2)
  382.   ELSE
  383.     RETURN FALSE
  384.   ENDIF
  385. ENDPROC
  386.  
  387. PROC em_main(epo:PTR TO em_pluginobj)
  388.   DEF m2, l2
  389.   m2, l2 := em_parsedata(epo)
  390.   epo.nlength := l2
  391.   RETURN TRUE
  392. ENDPROC
  393.  
  394. PROC em_end()      IS EMPTY
  395.  
  396. PROC em_info()     IS 'Troff2Text 1.04'
  397.  
  398. PROC em_pluginid() IS "FILE"
  399.  
  400. PROC em_format()   IS 'Troff'
  401.  
  402. PROC main()        IS EMPTY
  403.